Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-night-mode-disabled vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-1 vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-1 vector-sticky-header-enabled" lang="en" dir="ltr"><head>
<meta charset="UTF-8">
<title>Aspect-oriented programming</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="canonical" href="https://en.wikipedia.org/wiki/Aspect-oriented_programming"> <link href="./mw/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/user.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./mw/site.styles.css">
<link rel="stylesheet" type="text/css" href="./mw/noscript.css">
<link rel="stylesheet" type="text/css" href="./footer.css">
<link rel="stylesheet" type="text/css" href="./vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Aspect-oriented_programming rootpage-Aspect-oriented_programming skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading">
<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Aspect-oriented programming</span></span>
</h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="en" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">
<p class="mw-empty-elt">
</p><p>In <a href="Computing" title="Computing">computing</a>, <b>aspect-oriented programming</b> (<b>AOP</b>) is a <a href="Programming_paradigm" title="Programming paradigm">programming paradigm</a> that aims to increase <a href="Modularity_(programming)" class="mw-redirect" title="Modularity (programming)">modularity</a> by allowing the <a href="Separation_of_concerns" title="Separation of concerns">separation of</a> <a href="Cross-cutting_concern" title="Cross-cutting concern">cross-cutting concerns</a>. It does so by adding behavior to existing code (an <a href="Advice_(programming)" title="Advice (programming)">advice</a>) <i>without</i> modifying the code, instead separately specifying which code is modified via a "<a href="Pointcut" title="Pointcut">pointcut</a>" specification, such as "log all function calls when the function's name begins with 'set<span style="padding-right:.15em;">'</span>". This allows behaviors that are not central to the <a href="Business_logic" title="Business logic">business logic</a> (such as logging) to be added to a program without cluttering the code of core functions.
</p><p>AOP includes programming methods and tools that support the modularization of concerns at the level of the source code, while <b>aspect-oriented software development</b> refers to a whole engineering discipline.
</p><p>Aspect-oriented programming entails breaking down program logic into cohesive areas of functionality (so-called <i>concerns</i>). Nearly all programming paradigms support some level of grouping and <a href="Encapsulation_(computer_science)" class="mw-redirect" title="Encapsulation (computer science)">encapsulation</a> of concerns into separate, independent entities by providing abstractions (e.g., functions, procedures, modules, classes, methods) that can be used for implementing, abstracting, and composing these concerns. Some concerns "cut across" multiple abstractions in a program, and defy these forms of implementation. These concerns are called <i>cross-cutting concerns</i> or horizontal concerns.
</p><p><a href="Logging_(computing)" title="Logging (computing)">Logging</a> exemplifies a cross-cutting concern because a logging strategy must affect every logged part of the system. Logging thereby <i>crosscuts</i> all logged classes and methods.
</p><p>All AOP implementations have some cross-cutting expressions that encapsulate each concern in one place. The difference between implementations lies in the power, safety, and usability of the constructs provided. For example, interceptors that specify the methods to express a limited form of cross-cutting, without much support for type-safety or debugging. <a href="AspectJ" title="AspectJ">AspectJ</a> has a number of such expressions and encapsulates them in a special class, called an <a href="Aspect_(computer_science)" class="mw-redirect" title="Aspect (computer science)">aspect</a>. For example, an aspect can alter the behavior of the base code (the non-aspect part of a program) by applying <a href="Advice_in_aspect-oriented_programming" class="mw-redirect" title="Advice in aspect-oriented programming">advice</a> (additional behavior) at various <a href="Join_point" title="Join point">join points</a> (points in a program) specified in a quantification or query called a <a href="Pointcut" title="Pointcut">pointcut</a> (that detects whether a given join point matches). An aspect can also make binary-compatible structural changes to other classes, such as adding members or parents.
</p>
<meta property="mw:PageProp/toc">
<div class="mw-heading mw-heading2"><h2 id="History">History</h2></div>
<p>AOP has several direct antecedents A1 and A2:<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> <a href="Reflective_programming" title="Reflective programming">reflection</a> and <a href="Metaobject" title="Metaobject">metaobject</a> protocols, <a href="Subject-oriented_programming" title="Subject-oriented programming">subject-oriented programming</a>, Composition Filters, and Adaptive Programming.<sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup>
</p><p><a href="Gregor_Kiczales" title="Gregor Kiczales">Gregor Kiczales</a> and colleagues at <a href="Xerox_PARC" class="mw-redirect" title="Xerox PARC">Xerox PARC</a> developed the explicit concept of AOP and followed this with the <a href="AspectJ" title="AspectJ">AspectJ</a> AOP extension to Java. IBM's research team pursued a tool approach over a language design approach and in 2001 proposed <a href="Hyper/J" class="mw-redirect" title="Hyper/J">Hyper/J</a> and the <a href="Concern_Manipulation_Environment" class="mw-redirect" title="Concern Manipulation Environment">Concern Manipulation Environment</a>, which have not seen wide use.
</p><p>The examples in this article use AspectJ.
</p><p>The <a href="Microsoft_Transaction_Server" title="Microsoft Transaction Server">Microsoft Transaction Server</a> is considered to be the first major application of AOP followed by <a href="Enterprise_JavaBeans" class="mw-redirect" title="Enterprise JavaBeans">Enterprise JavaBeans</a>.<sup id="cite_ref-BoxSells2002_3-0" class="reference"><a href="#cite_note-BoxSells2002-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-RomanSriganesh2005_4-0" class="reference"><a href="#cite_note-RomanSriganesh2005-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Motivation_and_basic_concepts">Motivation and basic concepts</h2></div>
<p>Typically, an aspect is <i>scattered</i> or <i>tangled</i> as code, making it harder to understand and maintain. It is scattered by the function (such as logging) being spread over a number of unrelated functions that might use <i>its</i> function, possibly in entirely unrelated systems or written in different languages. Thus, changing logging can require modifying all affected modules. Aspects become tangled not only with the mainline function of the systems in which they are expressed but also with each other. Changing one concern thus entails understanding all the tangled concerns or having some means by which the effect of changes can be inferred.
</p><p>For example, consider a banking application with a conceptually very simple method for transferring an amount from one account to another:<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kt">void</span><span class="w"> </span><span class="nf">transfer</span><span class="p">(</span><span class="n">Account</span><span class="w"> </span><span class="n">fromAcc</span><span class="p">,</span><span class="w"> </span><span class="n">Account</span><span class="w"> </span><span class="n">toAcc</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">amount</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">fromAcc</span><span class="p">.</span><span class="na">getBalance</span><span class="p">()</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">amount</span><span class="p">)</span>
<span class="w"> </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">InsufficientFundsException</span><span class="p">();</span>

<span class="w"> </span><span class="n">fromAcc</span><span class="p">.</span><span class="na">withdraw</span><span class="p">(</span><span class="n">amount</span><span class="p">);</span>
<span class="w"> </span><span class="n">toAcc</span><span class="p">.</span><span class="na">deposit</span><span class="p">(</span><span class="n">amount</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<p>However, this transfer method overlooks certain considerations that a deployed application would require, such as verifying that the current user is authorized to perform this operation, encapsulating <a href="Database_transaction" title="Database transaction">database transactions</a> to prevent accidental data loss, and logging the operation for diagnostic purposes.
</p><p>A version with all those new concerns might look like this:
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kt">void</span><span class="w"> </span><span class="nf">transfer</span><span class="p">(</span><span class="n">Account</span><span class="w"> </span><span class="n">fromAcc</span><span class="p">,</span><span class="w"> </span><span class="n">Account</span><span class="w"> </span><span class="n">toAcc</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">amount</span><span class="p">,</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="p">,</span>
<span class="w"> </span><span class="n">Logger</span><span class="w"> </span><span class="n">logger</span><span class="p">,</span><span class="w"> </span><span class="n">Database</span><span class="w"> </span><span class="n">database</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"Transferring money..."</span><span class="p">);</span>
<span class="w"> </span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">isUserAuthorised</span><span class="p">(</span><span class="n">user</span><span class="p">,</span><span class="w"> </span><span class="n">fromAcc</span><span class="p">))</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"User has no permission."</span><span class="p">);</span>
<span class="w"> </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnauthorisedUserException</span><span class="p">();</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">fromAcc</span><span class="p">.</span><span class="na">getBalance</span><span class="p">()</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">amount</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"Insufficient funds."</span><span class="p">);</span>
<span class="w"> </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">InsufficientFundsException</span><span class="p">();</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="n">fromAcc</span><span class="p">.</span><span class="na">withdraw</span><span class="p">(</span><span class="n">amount</span><span class="p">);</span>
<span class="w"> </span><span class="n">toAcc</span><span class="p">.</span><span class="na">deposit</span><span class="p">(</span><span class="n">amount</span><span class="p">);</span>

<span class="w"> </span><span class="n">database</span><span class="p">.</span><span class="na">commitChanges</span><span class="p">();</span><span class="w"> </span><span class="c1">// Atomic operation.</span>

<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"Transaction successful."</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<p>In this example, other interests have become <i>tangled</i> with the basic functionality (sometimes called the <i>business logic concern</i>). Transactions, security, and logging all exemplify <i><a href="Cross-cutting_concern" title="Cross-cutting concern">cross-cutting concerns</a></i>.
</p><p>Now consider what would happen if we suddenly need to change the security considerations for the application. In the program's current version, security-related operations appear <i>scattered</i> across numerous methods, and such a change would require major effort.
</p><p>AOP tries to solve this problem by allowing the programmer to express cross-cutting concerns in stand-alone modules called <i>aspects</i>. Aspects can contain <i>advice</i> (code joined to specified points in the program) and <i>inter-type declarations</i> (structural members added to other classes). For example, a security module can include advice that performs a security check before accessing a bank account. The <a href="Pointcut" title="Pointcut">pointcut</a> defines the times (<a href="Join_point" title="Join point">join points</a>) when one can access a bank account, and the code in the advice body defines how the security check is implemented. That way, both the check and the places can be maintained in one place. Further, a good pointcut can anticipate later program changes, so if another developer creates a new method to access the bank account, the advice will apply to the new method when it executes.
</p><p>So for the example above implementing logging in an aspect:
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">aspect</span><span class="w"> </span><span class="n">Logger</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">Bank</span><span class="p">.</span><span class="na">transfer</span><span class="p">(</span><span class="n">Account</span><span class="w"> </span><span class="n">fromAcc</span><span class="p">,</span><span class="w"> </span><span class="n">Account</span><span class="w"> </span><span class="n">toAcc</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">amount</span><span class="p">,</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="p">,</span><span class="w"> </span><span class="n">Logger</span><span class="w"> </span><span class="n">logger</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"Transferring money..."</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">Bank</span><span class="p">.</span><span class="na">getMoneyBack</span><span class="p">(</span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">transactionId</span><span class="p">,</span><span class="w"> </span><span class="n">Logger</span><span class="w"> </span><span class="n">logger</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">logger</span><span class="p">.</span><span class="na">info</span><span class="p">(</span><span class="s">"User requested money back."</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="c1">// Other crosscutting code.</span>
<span class="p">}</span>
</pre></div>
<p>One can think of AOP as a debugging tool or a user-level tool. Advice should be reserved for cases in which one cannot get the function changed (user level)<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup> or do not want to change the function in production code (debugging).
</p>
<div class="mw-heading mw-heading2"><h2 id="Join_point_models">Join point models</h2></div>
<p>The advice-related component of an aspect-oriented language defines a join point model (JPM). A JPM defines three things:
</p>
<ol><li>When the advice can run. These are called <i><a href="Join_point" title="Join point">join points</a></i> because they are points in a running program where additional behavior can be usefully joined. A join point needs to be addressable and understandable by an ordinary programmer to be useful. It should also be stable across inconsequential program changes to maintain aspect stability. Many AOP implementations support method executions and field references as join points.</li>
<li>A way to specify (or <i>quantify</i>) join points, called <i><a href="Pointcut" title="Pointcut">pointcuts</a></i>. Pointcuts determine whether a given join point matches. Most useful pointcut languages use a syntax like the base language (for example, <a href="AspectJ" title="AspectJ">AspectJ</a> uses Java signatures) and allow reuse through naming and combination.</li>
<li>A means of specifying code to run at a join point. <a href="AspectJ" title="AspectJ">AspectJ</a> calls this <i><a href="Advice_in_aspect-oriented_programming" class="mw-redirect" title="Advice in aspect-oriented programming">advice</a></i>, and can run it before, after, and around join points. Some implementations also support defining a method in an aspect on another class.</li></ol>
<p>Join-point models can be compared based on the join points exposed, how join points are specified, the operations permitted at the join points, and the structural enhancements that can be expressed.
</p>
<div class="mw-heading mw-heading3"><h3 id="AspectJ's_join-point_model">AspectJ's join-point model</h3></div>
<style data-mw-deduplicate="TemplateStyles:r1236090951">
/* start https://en.wikipedia.org/ */


.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}


/* end https://en.wikipedia.org/ */
</style><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="AspectJ" title="AspectJ">AspectJ</a></div>
<div><ul><li>The join points in AspectJ include method or constructor call or execution, the initialization of a class or object, field read and write access, and exception handlers. They do not include loops, super calls, throws clauses, or multiple statements.</li><li>Pointcuts are specified by combinations of <i>primitive pointcut designators</i> (PCDs).
<p>"Kinded" PCDs match a particular kind of join point (e.g., method execution) and often take a Java-like signature as input. One such pointcut looks like this:
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">execution</span><span class="p">(</span><span class="o">*</span><span class="w"> </span><span class="k">set</span><span class="o">*</span><span class="p">(</span><span class="o">*</span><span class="p">))</span>
</pre></div>
<p>This pointcut matches a method-execution join point, if the method name starts with "<code>set</code>" and there is exactly one argument of any type.
</p><p>"Dynamic" PCDs check runtime types and bind variables. For example,
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">this</span><span class="p">(</span><span class="n">Point</span><span class="p">)</span>
</pre></div>
<p>This pointcut matches when the currently executing object is an instance of class <code>Point</code>. Note that the unqualified name of a class can be used via Java's normal type lookup.
</p><p>"Scope" PCDs limit the lexical scope of the join point. For example:
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">within</span><span class="p">(</span><span class="n">com</span><span class="p">.</span><span class="na">company</span><span class="p">.</span><span class="o">*</span><span class="p">)</span>
</pre></div>
<p>This pointcut matches any join point in any type in the <code>com.company</code> package. The <i><code>*</code></i> is one form of the wildcards that can be used to match many things with one signature.
</p><p>Pointcuts can be composed and named for reuse. For example:
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">pointcut</span><span class="w"> </span><span class="nf">set</span><span class="p">()</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">execution</span><span class="p">(</span><span class="o">*</span><span class="w"> </span><span class="k">set</span><span class="o">*</span><span class="p">(</span><span class="o">*</span><span class="p">)</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="k">this</span><span class="p">(</span><span class="n">Point</span><span class="p">)</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="k">within</span><span class="p">(</span><span class="n">com</span><span class="p">.</span><span class="na">company</span><span class="p">.</span><span class="o">*</span><span class="p">);</span>
</pre></div>
This pointcut matches a method-execution join point, if the method name starts with "<code>set</code>" and <code>this</code> is an instance of type <code>Point</code> in the <code>com.company</code> package. It can be referred to using the name "<code>set()</code>".</li><li>Advice specifies to run at (before, after, or around) a join point (specified with a pointcut) certain code (specified like code in a method). The AOP runtime invokes Advice automatically when the pointcut matches the join point. For example:
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="k">after</span><span class="p">()</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">set</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">Display</span><span class="p">.</span><span class="na">update</span><span class="p">();</span>
<span class="p">}</span>
</pre></div>
This effectively specifies: "if the <i><code>set()</code></i> pointcut matches the join point, run the code <code>Display.update()</code> after the join point completes."</li></ul></div>
<div class="mw-heading mw-heading3"><h3 id="Other_potential_join_point_models">Other potential join point models</h3></div>
<p>There are other kinds of JPMs. All advice languages can be defined in terms of their JPM. For example, a hypothetical aspect language for <a href="Unified_Modeling_Language" title="Unified Modeling Language">UML</a> may have the following JPM:
</p>
<ul><li>Join points are all model elements.</li>
<li>Pointcuts are some <a href="Boolean_expression" title="Boolean expression">Boolean expression</a> combining the model elements.</li>
<li>The means of affect at these points are a visualization of all the matched join points.</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Inter-type_declarations">Inter-type declarations</h3></div>
<p><i>Inter-type declarations</i> provide a way to express cross-cutting concerns affecting the structure of modules. Also known as <i>open classes</i> and <i><a href="Extension_method" title="Extension method">extension methods</a></i>, this enables programmers to declare in one place members or parents of another class, typically to combine all the code related to a concern in one aspect. For example, if a programmer implemented the cross-cutting display-update concern using visitors, an inter-type declaration using the <a href="Visitor_pattern" title="Visitor pattern">visitor pattern</a> might look like this in AspectJ:
</p>
<div class="mw-highlight mw-highlight-lang-aspectj mw-content-ltr" dir="ltr"><pre><span class="w"> </span><span class="k">aspect</span><span class="w"> </span><span class="n">DisplayUpdate</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">Point</span><span class="p">.</span><span class="na">acceptVisitor</span><span class="p">(</span><span class="n">Visitor</span><span class="w"> </span><span class="n">v</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">v</span><span class="p">.</span><span class="na">visit</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="c1">// other crosscutting code...</span>
<span class="w"> </span><span class="p">}</span>
</pre></div>
<p>This code snippet adds the <code>acceptVisitor</code> method to the <code>Point</code> class.
</p><p>Any structural additions are required to be compatible with the original class, so that clients of the existing class continue to operate, unless the AOP implementation can expect to control all clients at all times.
</p>
<div class="mw-heading mw-heading2"><h2 id="Implementation">Implementation</h2></div>
<p>AOP programs can affect other programs in two different ways, depending on the underlying languages and environments:
</p>
<ol><li>a combined program is produced, valid in the original language and indistinguishable from an ordinary program to the ultimate interpreter</li>
<li>the ultimate interpreter or environment is updated to understand and implement AOP features.</li></ol>
<p>The difficulty of changing environments means most implementations produce compatible combination programs through a type of <a href="Program_transformation" title="Program transformation">program transformation</a> known as <i>weaving</i>. An <a href="Aspect_weaver" title="Aspect weaver">aspect weaver</a> reads the aspect-oriented code and generates appropriate object-oriented code with the aspects integrated. The same AOP language can be implemented through a variety of weaving methods, so the semantics of a language should never be understood in terms of the weaving implementation. Only the speed of an implementation and its ease of deployment are affected by the method of combination used.
</p><p>Systems can implement source-level weaving using preprocessors (as C++ was implemented originally in <a href="CFront" class="mw-redirect" title="CFront">CFront</a>) that require access to program source files. However, Java's well-defined binary form enables bytecode weavers to work with any Java program in .class-file form. Bytecode weavers can be deployed during the build process or, if the weave model is per-class, during class loading. <a href="AspectJ" title="AspectJ">AspectJ</a> started with source-level weaving in 2001, delivered a per-class bytecode weaver in 2002, and offered advanced load-time support after the integration of <a href="AspectWerkz" class="mw-redirect" title="AspectWerkz">AspectWerkz</a> in 2005.
</p><p>Any solution that combines programs at runtime must provide views that segregate them properly to maintain the programmer's segregated model. Java's bytecode support for multiple source files enables any debugger to step through a properly woven .class file in a source editor. However, some third-party decompilers cannot process woven code because they expect code produced by Javac rather than all supported bytecode forms (see also <a href="#Criticism">§&nbsp;Criticism</a>, below).
</p><p>Deploy-time weaving offers another approach.<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup> This basically implies post-processing, but rather than patching the generated code, this weaving approach <i>subclasses</i> existing classes so that the modifications are introduced by method-overriding. The existing classes remain untouched, even at runtime, and all existing tools, such as debuggers and profilers, can be used during development. A similar approach has already proven itself in the implementation of many <a href="Java_EE" class="mw-redirect" title="Java EE">Java EE</a> application servers, such as <a href="IBM" title="IBM">IBM</a>'s <a href="WebSphere" class="mw-redirect" title="WebSphere">WebSphere</a>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Terminology">Terminology</h3></div>
<p>Standard terminology used in Aspect-oriented programming may include:
</p>
<dl><dt>Cross-cutting concerns</dt>
<dd><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Cross-cutting_concern" title="Cross-cutting concern">Cross-cutting concern</a></div> Even though most classes in an object-oriented model will perform a single, specific function, they often share common, secondary requirements with other classes. For example, we may want to add logging to classes within the data-access layer and also to classes in the UI layer whenever a thread enters or exits a method. Further concerns can be related to security such as <a href="Access_control#Computer_security" title="Access control">access control</a><sup id="cite_ref-dewin2002_8-0" class="reference"><a href="#cite_note-dewin2002-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup> or <a href="Information_flow_(information_theory)" title="Information flow (information theory)">information flow control</a>.<sup id="cite_ref-pasquier2014_9-0" class="reference"><a href="#cite_note-pasquier2014-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> Even though each class has a very different primary functionality, the code needed to perform the secondary functionality is often identical.</dd>
<dt></dt>
<dt>Advice</dt>
<dd><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Advice_(programming)" title="Advice (programming)">Advice (programming)</a></div> This is the additional code that you want to apply to your existing model. In our example, this is the logging code that we want to apply whenever the thread enters or exits a method.:</dd>
<dt>Pointcut</dt>
<dd><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Pointcut" title="Pointcut">Pointcut</a></div> This refers to the point of execution in the application at which cross-cutting concern needs to be applied. In our example, a pointcut is reached when the thread enters a method, and another pointcut is reached when the thread exits the method.</dd>
<dt></dt>
<dt>Aspect</dt>
<dd><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Aspect_(computer_science)" class="mw-redirect" title="Aspect (computer science)">Aspect (computer science)</a></div> The combination of the pointcut and the advice is termed an aspect. In the example above, we add a logging aspect to our application by defining a pointcut and giving the correct advice.</dd></dl>
<div class="mw-heading mw-heading2"><h2 id="Comparison_to_other_programming_paradigms">Comparison to other programming paradigms</h2></div>
<p>Aspects emerged from <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a> and <a href="Reflective_programming" title="Reflective programming">reflective programming</a>. AOP languages have functionality similar to, but more restricted than, <a href="Metaobject" title="Metaobject">metaobject protocols</a>. Aspects relate closely to programming concepts like <a href="Subjects_(programming)" class="mw-redirect" title="Subjects (programming)">subjects</a>, <a href="Mixin" title="Mixin">mixins</a>, and <a href="Delegation_(programming)" class="mw-redirect" title="Delegation (programming)">delegation</a>. Other ways to use aspect-oriented programming paradigms include <a href="Composition_Filters" class="mw-redirect" title="Composition Filters">Composition Filters</a> and the <a href="Hyper/J" class="mw-redirect" title="Hyper/J">hyperslices</a> approach. Since at least the 1970s, developers have been using forms of interception and dispatch-patching that resemble some of the implementation methods for AOP, but these never had the semantics that the cross-cutting specifications provide in one place.
</p><p>Designers have considered alternative ways to achieve separation of code, such as <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>'s partial types, but such approaches lack a quantification mechanism that allows reaching several join points of the code with one declarative statement.
</p><p>Though it may seem unrelated, in testing, the use of mocks or stubs requires the use of AOP techniques, such as around advice. Here the collaborating objects are for the purpose of the test, a cross-cutting concern. Thus, the various Mock Object frameworks provide these features. For example, a process invokes a service to get a balance amount. In the test of the process, it is unimportant where the amount comes from, but only that the process uses the balance according to the requirements.
</p>
<div class="mw-heading mw-heading2"><h2 id="Adoption_issues">Adoption issues</h2></div>
<p>Programmers need to be able to read and understand code to prevent errors.<sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>
Even with proper education, understanding cross-cutting concerns can be difficult without proper support for visualizing both static structure and the dynamic flow of a program.<sup id="cite_ref-harmful_11-0" class="reference"><a href="#cite_note-harmful-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup> Starting in 2002, AspectJ began to provide IDE plug-ins to support the visualizing of cross-cutting concerns. Those features, as well as aspect code assist and <a href="Code_refactoring" title="Code refactoring">refactoring</a>, are now common.
</p><p>Given the power of AOP, making a logical mistake in expressing cross-cutting can lead to widespread program failure. Conversely, another programmer may change the join points in a program, such as by renaming or moving methods, in ways that the aspect writer did not anticipate and with <a href="Unforeseen_consequences" class="mw-redirect" title="Unforeseen consequences">unforeseen consequences</a>. One advantage of modularizing cross-cutting concerns is enabling one programmer to easily affect the entire system. As a result, such problems manifest as a conflict over responsibility between two or more developers for a given failure. AOP can expedite solving these problems, as only the aspect must be changed. Without AOP, the corresponding problems can be much more spread out.
</p>
<div class="mw-heading mw-heading2"><h2 id="Criticism">Criticism</h2></div>
<p>The most basic criticism of the effect of AOP is that control flow is obscured, and that it is not only worse than the much-maligned <a href="GOTO" class="mw-redirect" title="GOTO">GOTO</a> statement, but is closely analogous to the joke <a href="COME_FROM" class="mw-redirect" title="COME FROM">COME FROM</a> statement.<sup id="cite_ref-harmful_11-1" class="reference"><a href="#cite_note-harmful-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup> The <i>obliviousness of application</i>, which is fundamental to many definitions of AOP (the code in question has no indication that an advice will be applied, which is specified instead in the pointcut), means that the advice is not visible, in contrast to an explicit method call.<sup id="cite_ref-harmful_11-2" class="reference"><a href="#cite_note-harmful-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup> For example, compare the COME FROM program:<sup id="cite_ref-harmful_11-3" class="reference"><a href="#cite_note-harmful-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-basic mw-content-ltr" dir="ltr"><pre><span class="w"> </span><span class="il">5</span><span class="w"> </span><span class="kr">INPUT</span><span class="w"> </span><span class="vg">X</span>
<span class="nl">10</span><span class="w"> </span><span class="kr">PRINT</span><span class="w"> </span><span class="c1">'Result is&nbsp;:'</span>
<span class="nl">15</span><span class="w"> </span><span class="kr">PRINT</span><span class="w"> </span><span class="vg">X</span>
<span class="hll"><span class="nl">20</span><span class="w"> </span><span class="vg">COME</span><span class="w"> </span><span class="vg">FROM</span><span class="w"> </span><span class="il">10</span>
</span><span class="nl">25</span><span class="w"> </span><span class="vg">X</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="vg">X</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="vg">X</span>
<span class="nl">30</span><span class="w"> </span><span class="kr">RETURN</span>
</pre></div>
<p>with an AOP fragment with analogous semantics:
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="n">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">input</span><span class="w"> </span><span class="n">x</span>
<span class="w"> </span><span class="nf">print</span><span class="p">(</span><span class="n">result</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
<span class="p">}</span>
<span class="n">input</span><span class="w"> </span><span class="nf">result</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="p">}</span>
<span class="n">around</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">):</span><span class="w"> </span><span class="n">call</span><span class="p">(</span><span class="n">result</span><span class="p">(</span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="n">args</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">temp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">proceed</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="hll"><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">temp</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">temp</span>
</span><span class="p">}</span>
</pre></div>
<p>Indeed, the pointcut may depend on runtime condition and thus not be statically deterministic. This can be mitigated but not solved by static analysis and IDE support showing which advices <i>potentially</i> match.
</p><p>General criticisms are that AOP purports to improve "both modularity and the structure of code", but some counter that it instead undermines these goals and impedes "independent development and understandability of programs".<sup id="cite_ref-steimann_13-0" class="reference"><a href="#cite_note-steimann-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> Specifically, quantification by pointcuts breaks modularity: "one must, in general, have whole-program knowledge to reason about the dynamic execution of an aspect-oriented program."<sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup> Further, while its goals (modularizing cross-cutting concerns) are well understood, its actual definition is unclear and not clearly distinguished from other well-established techniques.<sup id="cite_ref-steimann_13-1" class="reference"><a href="#cite_note-steimann-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> Cross-cutting concerns potentially cross-cut each other, requiring some resolution mechanism, such as ordering.<sup id="cite_ref-steimann_13-2" class="reference"><a href="#cite_note-steimann-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> Indeed, aspects can apply to themselves, leading to problems such as the <a href="Liar_paradox" title="Liar paradox">liar paradox</a>.<sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup>
</p><p>Technical criticisms include that the quantification of pointcuts (defining where advices are executed) is "extremely sensitive to changes in the program", which is known as the <i>fragile pointcut problem</i>.<sup id="cite_ref-steimann_13-3" class="reference"><a href="#cite_note-steimann-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup> The problems with pointcuts are deemed intractable. If one replaces the quantification of pointcuts with explicit annotations, one obtains <a href="Attribute-oriented_programming" title="Attribute-oriented programming">attribute-oriented programming</a> instead, which is simply an explicit subroutine call and suffers the identical problem of scattering, which AOP was designed to solve.<sup id="cite_ref-steimann_13-4" class="reference"><a href="#cite_note-steimann-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading2"><h2 id="Implementations">Implementations</h2></div>
<p>Many <a href="Programming_language" title="Programming language">programming languages</a> have implemented AOP, within the language, or as an external <a href="Library_(computing)" title="Library (computing)">library</a>, including:
</p>
<ul><li><a href=".NET" title=".NET">.NET</a> framework languages (<a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>, <a href="Visual_Basic_(.NET)" title="Visual Basic (.NET)">Visual Basic (.NET)</a> (VB.NET))<sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup>
<ul><li><a rel="nofollow" class="external text" href="https://www.postsharp.net/">PostSharp</a> is a commercial AOP implementation with a free but limited edition.</li>
<li><a href="Unity_Application_Block" class="mw-redirect" title="Unity Application Block">Unity</a> provides an API to facilitate proven practices in core areas of programming including data access, security, logging, exception handling and others.</li>
<li><a rel="nofollow" class="external text" href="https://github.com/tfreyburger/aspectDN/">AspectDN</a> is an AOP implementation allowing to weave the aspects directly on the .NET executable files.</li></ul></li>
<li><a href="ActionScript" title="ActionScript">ActionScript</a><sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a><sup id="cite_ref-18" class="reference"><a href="#cite_note-18"><span class="cite-bracket">[</span>18<span class="cite-bracket">]</span></a></sup></li>
<li><a href="AutoHotkey" title="AutoHotkey">AutoHotkey</a><sup id="cite_ref-19" class="reference"><a href="#cite_note-19"><span class="cite-bracket">[</span>19<span class="cite-bracket">]</span></a></sup></li>
<li><a href="C_(programming_language)" title="C (programming language)">C</a>, <a href="C%2B%2B" title="C++">C++</a><sup id="cite_ref-20" class="reference"><a href="#cite_note-20"><span class="cite-bracket">[</span>20<span class="cite-bracket">]</span></a></sup></li>
<li><a href="COBOL" title="COBOL">COBOL</a><sup id="cite_ref-21" class="reference"><a href="#cite_note-21"><span class="cite-bracket">[</span>21<span class="cite-bracket">]</span></a></sup></li>
<li>The <a href="Cocoa_(API)" title="Cocoa (API)">Cocoa</a> <a href="Objective-C" title="Objective-C">Objective-C</a> frameworks<sup id="cite_ref-22" class="reference"><a href="#cite_note-22"><span class="cite-bracket">[</span>22<span class="cite-bracket">]</span></a></sup></li>
<li><a href="ColdFusion" class="mw-redirect" title="ColdFusion">ColdFusion</a><sup id="cite_ref-23" class="reference"><a href="#cite_note-23"><span class="cite-bracket">[</span>23<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Common_Lisp" title="Common Lisp">Common Lisp</a><sup id="cite_ref-24" class="reference"><a href="#cite_note-24"><span class="cite-bracket">[</span>24<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Delphi_(software)" title="Delphi (software)">Delphi</a><sup id="cite_ref-25" class="reference"><a href="#cite_note-25"><span class="cite-bracket">[</span>25<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-26" class="reference"><a href="#cite_note-26"><span class="cite-bracket">[</span>26<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-27" class="reference"><a href="#cite_note-27"><span class="cite-bracket">[</span>27<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Delphi_Prism" class="mw-redirect" title="Delphi Prism">Delphi Prism</a><sup id="cite_ref-28" class="reference"><a href="#cite_note-28"><span class="cite-bracket">[</span>28<span class="cite-bracket">]</span></a></sup></li>
<li><a href="E_(verification_language)" title="E (verification language)">e</a> (IEEE 1647)</li>
<li><a href="Emacs_Lisp" title="Emacs Lisp">Emacs Lisp</a><sup id="cite_ref-29" class="reference"><a href="#cite_note-29"><span class="cite-bracket">[</span>29<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Groovy_(programming_language)" class="mw-redirect" title="Groovy (programming language)">Groovy</a></li>
<li><a href="Haskell" title="Haskell">Haskell</a><sup id="cite_ref-30" class="reference"><a href="#cite_note-30"><span class="cite-bracket">[</span>30<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Java_(programming_language)" title="Java (programming language)">Java</a><sup id="cite_ref-31" class="reference"><a href="#cite_note-31"><span class="cite-bracket">[</span>31<span class="cite-bracket">]</span></a></sup>
<ul><li><a href="AspectJ" title="AspectJ">AspectJ</a></li></ul></li>
<li><a href="JavaScript" title="JavaScript">JavaScript</a><sup id="cite_ref-32" class="reference"><a href="#cite_note-32"><span class="cite-bracket">[</span>32<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Logtalk_(programming_language)" class="mw-redirect" title="Logtalk (programming language)">Logtalk</a><sup id="cite_ref-33" class="reference"><a href="#cite_note-33"><span class="cite-bracket">[</span>33<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Lua_(programming_language)" class="mw-redirect" title="Lua (programming language)">Lua</a><sup id="cite_ref-34" class="reference"><a href="#cite_note-34"><span class="cite-bracket">[</span>34<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Make_(software)" title="Make (software)">make</a><sup id="cite_ref-35" class="reference"><a href="#cite_note-35"><span class="cite-bracket">[</span>35<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Matlab" class="mw-redirect" title="Matlab">Matlab</a><sup id="cite_ref-36" class="reference"><a href="#cite_note-36"><span class="cite-bracket">[</span>36<span class="cite-bracket">]</span></a></sup></li>
<li><a href="ML_(programming_language)" title="ML (programming language)">ML</a><sup id="cite_ref-37" class="reference"><a href="#cite_note-37"><span class="cite-bracket">[</span>37<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Nemerle" title="Nemerle">Nemerle</a><sup id="cite_ref-38" class="reference"><a href="#cite_note-38"><span class="cite-bracket">[</span>38<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Perl" title="Perl">Perl</a><sup id="cite_ref-39" class="reference"><a href="#cite_note-39"><span class="cite-bracket">[</span>39<span class="cite-bracket">]</span></a></sup></li>
<li><a href="PHP" title="PHP">PHP</a><sup id="cite_ref-40" class="reference"><a href="#cite_note-40"><span class="cite-bracket">[</span>40<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Prolog" title="Prolog">Prolog</a><sup id="cite_ref-41" class="reference"><a href="#cite_note-41"><span class="cite-bracket">[</span>41<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Python_(programming_language)" title="Python (programming language)">Python</a><sup id="cite_ref-42" class="reference"><a href="#cite_note-42"><span class="cite-bracket">[</span>42<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Racket_(programming_language)" title="Racket (programming language)">Racket</a><sup id="cite_ref-43" class="reference"><a href="#cite_note-43"><span class="cite-bracket">[</span>43<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a><sup id="cite_ref-44" class="reference"><a href="#cite_note-44"><span class="cite-bracket">[</span>44<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-45" class="reference"><a href="#cite_note-45"><span class="cite-bracket">[</span>45<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-46" class="reference"><a href="#cite_note-46"><span class="cite-bracket">[</span>46<span class="cite-bracket">]</span></a></sup></li>
<li><a href="Squeak" title="Squeak">Squeak</a> <a href="Smalltalk" title="Smalltalk">Smalltalk</a><sup id="cite_ref-47" class="reference"><a href="#cite_note-47"><span class="cite-bracket">[</span>47<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-48" class="reference"><a href="#cite_note-48"><span class="cite-bracket">[</span>48<span class="cite-bracket">]</span></a></sup></li>
<li><a href="UML_2" class="mw-redirect" title="UML 2">UML 2.0</a><sup id="cite_ref-49" class="reference"><a href="#cite_note-49"><span class="cite-bracket">[</span>49<span class="cite-bracket">]</span></a></sup></li>
<li><a href="XML" title="XML">XML</a><sup id="cite_ref-50" class="reference"><a href="#cite_note-50"><span class="cite-bracket">[</span>50<span class="cite-bracket">]</span></a></sup></li></ul>
<div class="mw-heading mw-heading2"><h2 id="See_also">See also</h2></div>
<ul><li><a href="Distributed_AOP" title="Distributed AOP">Distributed AOP</a></li>
<li><a href="Attribute_grammar" title="Attribute grammar">Attribute grammar</a>, a formalism that can be used for aspect-oriented programming on <a href="Functional_programming" title="Functional programming">functional programming</a> languages</li>
<li><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a></li>
<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subject-oriented programming</a>, an alternative to aspect-oriented programming</li>
<li><a href="Role-oriented_programming" title="Role-oriented programming">Role-oriented programming</a>, an alternative to aspect-oriented programming</li>
<li><a href="Predicate_dispatch" title="Predicate dispatch">Predicate dispatch</a>, an older alternative to aspect-oriented programming</li>
<li><a href="Executable_UML" title="Executable UML">Executable UML</a></li>
<li><a href="Decorator_pattern" title="Decorator pattern">Decorator pattern</a></li>
<li><a href="Domain-driven_design" title="Domain-driven design">Domain-driven design</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="Notes_and_references">Notes and references</h2></div>
<style data-mw-deduplicate="TemplateStyles:r1239543626">
/* start https://en.wikipedia.org/ */


.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}


/* end https://en.wikipedia.org/ */
</style><div class="reflist">
<div class="mw-references-wrap mw-references-columns"><ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><b><a href="#cite_ref-1">^</a></b></span> <span class="reference-text"><style data-mw-deduplicate="TemplateStyles:r1238218222">
/* start https://en.wikipedia.org/ */


.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}


/* end https://en.wikipedia.org/ */
</style><cite id="CITEREFKiczalesLampingMendhekarMaeda1997" class="citation conference cs1"><a href="Gregor_Kiczales" title="Gregor Kiczales">Kiczales, G.</a>; Lamping, J.; Mendhekar, A.; Maeda, C.; Lopes, C.; Loingtier, J. M.; Irwin, J. (1997). <a rel="nofollow" class="external text" href="http://www.cs.ubc.ca/~gregor/papers/kiczales-ECOOP1997-AOP.pdf"><i>Aspect-oriented programming</i></a> <span class="cs1-format">(PDF)</span>. <a href="European_Conference_on_Object-Oriented_Programming" title="European Conference on Object-Oriented Programming">ECOOP</a>'97. <i>Proceedings of the 11th European Conference on Object-Oriented Programming</i>. <a href="Lecture_Notes_in_Computer_Science" title="Lecture Notes in Computer Science">Lecture Notes in Computer Science</a> (LNCS). Vol.&nbsp;1241. pp.&nbsp;<span class="nowrap">220–</span>242. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a>&nbsp;<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.115.8660">10.1.1.115.8660</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2FBFb0053381">10.1007/BFb0053381</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>3-540-63089-9</bdi>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160112141810/http://www.cs.ubc.ca/%7Egregor/papers/kiczales-ECOOP1997-AOP.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 12 January 2016.</cite></span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-2">^</a></b></span> <span class="reference-text">"Adaptive Object Oriented Programming: The Demeter Approach with Propagation Patterns" <i>Karl Liebherr</i> 1996 <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>0-534-94602-X</bdi> presents a well-worked version of essentially the same thing (Lieberherr subsequently recognized this and reframed his approach).</span>
</li>
<li id="cite_note-BoxSells2002-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-BoxSells2002_3-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFDon_BoxChris_Sells2002" class="citation book cs1">Don Box; Chris Sells (4 November 2002). <span class="id-lock-registration" title="Free registration required"><a rel="nofollow" class="external text" href="https://archive.org/details/essentialnetcomm01boxd"><i>Essential.NET: The common language runtime</i></a></span>. Addison-Wesley Professional. p.&nbsp;<a rel="nofollow" class="external text" href="https://archive.org/details/essentialnetcomm01boxd/page/206">206</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-0-201-73411-9</bdi><span class="reference-accessdate">. Retrieved <span class="nowrap">4 October</span> 2011</span>.</cite></span>
</li>
<li id="cite_note-RomanSriganesh2005-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-RomanSriganesh2005_4-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFRomanSriganeshBrose2005" class="citation book cs1">Roman, Ed; Sriganesh, Rima Patel; Brose, Gerald (1 January 2005). <a rel="nofollow" class="external text" href="https://books.google.com/books?id=60oym_-uu3EC&amp;pg=PA285"><i>Mastering Enterprise JavaBeans</i></a>. John Wiley and Sons. p.&nbsp;285. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-0-7645-8492-3</bdi><span class="reference-accessdate">. Retrieved <span class="nowrap">4 October</span> 2011</span>.</cite></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text">Note: The examples in this article appear in a syntax that resembles that of the <a href="Java_(programming_language)" title="Java (programming language)">Java</a> language.</span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.gnu.org/software/emacs/manual/html_node/elisp/Advising-Functions.html">"gnu.org"</a>. GNU Project. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20171224053656/http://www.gnu.org/software/emacs/manual/html_node/elisp/Advising-Functions.html">Archived</a> from the original on 24 December 2017<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><b><a href="#cite_ref-7">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20051008065854/http://www.forum2.org/tal/AspectJ2EE.pdf">"Archived copy"</a> <span class="cs1-format">(PDF)</span>. Archived from <a rel="nofollow" class="external text" href="http://www.forum2.org/tal/AspectJ2EE.pdf">the original</a> <span class="cs1-format">(PDF)</span> on 8 October 2005<span class="reference-accessdate">. Retrieved <span class="nowrap">19 June</span> 2005</span>.</cite><span class="cs1-maint citation-comment"><code class="cs1-code">{{cite web}}</code>: CS1 maint: archived copy as title (link)</span></span>
</li>
<li id="cite_note-dewin2002-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-dewin2002_8-0">^</a></b></span> <span class="reference-text">B. De Win, B. Vanhaute and B. De Decker. "Security through aspect-oriented programming". In <i>Advances in Network and Distributed Systems Security</i> (2002).</span>
</li>
<li id="cite_note-pasquier2014-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-pasquier2014_9-0">^</a></b></span> <span class="reference-text">T. Pasquier, J. Bacon and B. Shand. "FlowR: Aspect Oriented Programming for Information Flow Control in Ruby". In <i>ACM Proceedings of the 13th international conference on Modularity (Aspect Oriented Software Development)</i> (2014).</span>
</li>
<li id="cite_note-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-10">^</a></b></span> <span class="reference-text"><a href="Edsger_Dijkstra" class="mw-redirect" title="Edsger Dijkstra">Edsger Dijkstra</a>, <a rel="nofollow" class="external text" href="http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF"><i>Notes on Structured Programming</i></a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20061012020239/http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF">Archived</a> 2006-10-12 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, pg. 1-2</span>
</li>
<li id="cite_note-harmful-11"><span class="mw-cite-backlink">^ <a href="#cite_ref-harmful_11-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-harmful_11-1"><sup><i><b>b</b></i></sup></a> <a href="#cite_ref-harmful_11-2"><sup><i><b>c</b></i></sup></a> <a href="#cite_ref-harmful_11-3"><sup><i><b>d</b></i></sup></a></span> <span class="reference-text"><cite id="CITEREFConstantinidesSkotiniotisStörzer2004" class="citation conference cs1">Constantinides, Constantinos; Skotiniotis, Therapon; Störzer, Maximilian (September 2004). <a rel="nofollow" class="external text" href="http://pp.info.uni-karlsruhe.de/uploads/publikationen/constantinides04eiwas.pdf"><i>AOP Considered Harmful</i></a> <span class="cs1-format">(PDF)</span>. European Interactive Workshop on Aspects in Software (EIWAS). Berlin, Germany. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160323061458/https://pp.info.uni-karlsruhe.de/uploads/publikationen/constantinides04eiwas.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 23 March 2016<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-12">^</a></b></span> <span class="reference-text"><a href="https://wiki.c2.com/?ComeFrom" class="extiw external" title="c2:ComeFrom">C2:ComeFrom</a></span>
</li>
<li id="cite_note-steimann-13"><span class="mw-cite-backlink">^ <a href="#cite_ref-steimann_13-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-steimann_13-1"><sup><i><b>b</b></i></sup></a> <a href="#cite_ref-steimann_13-2"><sup><i><b>c</b></i></sup></a> <a href="#cite_ref-steimann_13-3"><sup><i><b>d</b></i></sup></a> <a href="#cite_ref-steimann_13-4"><sup><i><b>e</b></i></sup></a></span> <span class="reference-text"><cite id="CITEREFSteimann2006" class="citation journal cs1">Steimann, F. (2006). "The paradoxical success of aspect-oriented programming". <i>ACM SIGPLAN Notices</i>. <b>41</b> (10): <span class="nowrap">481–</span>497. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a>&nbsp;<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.457.2210">10.1.1.457.2210</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F1167515.1167514">10.1145/1167515.1167514</a>.</cite>, (<a rel="nofollow" class="external text" href="http://people.dsv.su.se/~johano/ioor/succ_aop.pdf">slides</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160304060007/http://people.dsv.su.se/~johano/ioor/succ_aop.pdf">Archived</a> 2016-03-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>,<a rel="nofollow" class="external text" href="http://www.eecs.ucf.edu/~leavens/modular-aop/Discussion.pdf">slides 2</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150923234021/http://www.eecs.ucf.edu/~leavens/modular-aop/Discussion.pdf">Archived</a> 2015-09-23 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.oopsla.org/2006/submission/essays/the_paradoxical_success_of_aspect-oriented_programming.html">abstract</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150924060711/http://www.oopsla.org/2006/submission/essays/the_paradoxical_success_of_aspect-oriented_programming.html">Archived</a> 2015-09-24 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>), Friedrich Steimann, Gary T. Leavens, <a href="OOPSLA" title="OOPSLA">OOPSLA</a> 2006</span>
</li>
<li id="cite_note-14"><span class="mw-cite-backlink"><b><a href="#cite_ref-14">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.eecs.ucf.edu/~leavens/modular-aop/">"More Modular Reasoning for Aspect-Oriented Programs"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150812045258/http://www.eecs.ucf.edu/~leavens/modular-aop/">Archived</a> from the original on 12 August 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-15"><span class="mw-cite-backlink"><b><a href="#cite_ref-15">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.fernuni-hagen.de/ps/pubs/FOAL2006.pdf">"AOP and the Antinomy of the Liar"</a> <span class="cs1-format">(PDF)</span>. <i>fernuni-hagen.de</i>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20170809201001/http://www.fernuni-hagen.de/ps/pubs/FOAL2006.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 9 August 2017<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-16"><span class="mw-cite-backlink"><b><a href="#cite_ref-16">^</a></b></span> <span class="reference-text">Numerous:
<a rel="nofollow" class="external text" href="https://github.com/vc3/Afterthought">Afterthought</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160315162029/https://github.com/vc3/Afterthought">Archived</a> 2016-03-15 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.rapier-loom.net/">LOOM.NET</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20080827215106/http://www.rapier-loom.net/">Archived</a> 2008-08-27 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.codeplex.com/entlib">Enterprise Library 3.0 Policy Injection Application Block</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070119154829/http://www.codeplex.com/entlib">Archived</a> 2007-01-19 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://sourceforge.net/projects/aspectdng/">AspectDNG</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20040929053513/http://sourceforge.net/projects/aspectdng">Archived</a> 2004-09-29 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.castleproject.org/projects/dynamicproxy/">DynamicProxy</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20151205001755/http://www.castleproject.org/projects/dynamicproxy/">Archived</a> 2015-12-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://composestar.sourceforge.net/">Compose*</a> <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20050821193804/http://composestar.sourceforge.net/">Archived</a> 2005-08-21 at Wikiwix, <a rel="nofollow" class="external text" href="http://www.postsharp.net/">PostSharp</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160503095409/https://www.postsharp.net/">Archived</a> 2016-05-03 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.seasar.org/en/dotnet/">Seasar.NET</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060725015434/http://www.seasar.org/en/dotnet/">Archived</a> 2006-07-25 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://dotspect.tigris.org/">DotSpect (.SPECT)</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060331071126/http://dotspect.tigris.org/">Archived</a> 2006-03-31 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.springframework.net/">Spring.NET</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060402205922/http://springframework.net/">Archived</a> 2006-04-02 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> (as part of its functionality), <a rel="nofollow" class="external text" href="https://www.cs.columbia.edu/~eaddy/wicca">Wicca and Phx.Morph</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20061207110849/http://www1.cs.columbia.edu/~eaddy/wicca/">Archived</a> 2006-12-07 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://setpoint.codehaus.org/">SetPoint</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081007002006/http://setpoint.codehaus.org/">Archived</a> 2008-10-07 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
<li id="cite_note-17"><span class="mw-cite-backlink"><b><a href="#cite_ref-17">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.as3commons.org/as3-commons-bytecode">"Welcome to as3-commons-bytecode"</a>. <i>as3commons.org</i>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20141003100345/http://www.as3commons.org/as3-commons-bytecode/">Archived</a> from the original on 3 October 2014<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-18"><span class="mw-cite-backlink"><b><a href="#cite_ref-18">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.adacore.com/uploads/technical-papers/Ada2012_Rational_Introducion.pdf">"Ada2012 Rationale"</a> <span class="cs1-format">(PDF)</span>. <i>adacore.com</i>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160418132340/http://www.adacore.com/uploads/technical-papers/Ada2012_Rational_Introducion.pdf">Archived</a> <span class="cs1-format">(PDF)</span> from the original on 18 April 2016<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-19"><span class="mw-cite-backlink"><b><a href="#cite_ref-19">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://archive.today/20130117125117/http://www.autohotkey.com/forum/viewtopic.php?p=243426">"Function Hooks"</a>. <i>autohotkey.com</i>. Archived from <a rel="nofollow" class="external text" href="http://www.autohotkey.com/forum/viewtopic.php?p=243426">the original</a> on 17 January 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-20"><span class="mw-cite-backlink"><b><a href="#cite_ref-20">^</a></b></span> <span class="reference-text">Several: <a href="AspectC%2B%2B" title="AspectC++">AspectC++</a>, <a rel="nofollow" class="external text" href="http://wwwiti.cs.uni-magdeburg.de/iti_db/forschung/fop/featurec/">FeatureC++</a>, <a rel="nofollow" class="external text" href="http://www.cs.ubc.ca/labs/spl/projects/aspectc.html">AspectC</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060821190630/http://www.cs.ubc.ca/labs/spl/projects/aspectc.html">Archived</a> 2006-08-21 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.aspectc.net/">AspeCt-oriented C</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081120144608/http://www.aspectc.net/">Archived</a> 2008-11-20 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://archive.today/20120721212648/http://www.bramadams.org/aspicere/">Aspicere</a></span>
</li>
<li id="cite_note-21"><span class="mw-cite-backlink"><b><a href="#cite_ref-21">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://homepages.vub.ac.be/~kdeschut/cobble/">"Cobble"</a>. <i>vub.ac.be</i><span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-22"><span class="mw-cite-backlink"><b><a href="#cite_ref-22">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20071026022525/http://www.ood.neu.edu/aspectcocoa/">"AspectCocoa"</a>. <i>neu.edu</i>. Archived from <a rel="nofollow" class="external text" href="http://www.ood.neu.edu/aspectcocoa/">the original</a> on 26 October 2007<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-23"><span class="mw-cite-backlink"><b><a href="#cite_ref-23">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20051105014513/http://coldspringframework.org/">"ColdSpring Framework: Welcome"</a>. 5 November 2005. Archived from the original on 5 November 2005<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite><span class="cs1-maint citation-comment"><code class="cs1-code">{{cite web}}</code>: CS1 maint: bot: original URL status unknown (link)</span></span>
</li>
<li id="cite_note-24"><span class="mw-cite-backlink"><b><a href="#cite_ref-24">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://common-lisp.net/project/closer/aspectl.html">"Closer Project: AspectL"</a>. <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20110223172923/http://common-lisp.net/project/closer/aspectl.html">Archived</a> from the original on 23 February 2011<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-25"><span class="mw-cite-backlink"><b><a href="#cite_ref-25">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://code.google.com/p/infra/">"infra – Frameworks Integrados para Delphi – Google Project Hosting"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150909070130/http://code.google.com/p/infra/">Archived</a> from the original on 9 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-26"><span class="mw-cite-backlink"><b><a href="#cite_ref-26">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://code.google.com/p/meaop/">"meaop – MeSDK: MeObjects, MeRTTI, MeAOP – Delphi AOP(Aspect Oriented Programming), MeRemote, MeService... – Google Project Hosting"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150910210536/http://code.google.com/p/meaop/">Archived</a> from the original on 10 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-27"><span class="mw-cite-backlink"><b><a href="#cite_ref-27">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://code.google.com/p/delphisorcery/">"Google Project Hosting"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20141225080131/https://code.google.com/p/delphisorcery/">Archived</a> from the original on 25 December 2014<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-28"><span class="mw-cite-backlink"><b><a href="#cite_ref-28">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20120123094027/http://prismwiki.codegear.com/en/Cirrus">"RemObjects Cirrus"</a>. <i>codegear.com</i>. Archived from <a rel="nofollow" class="external text" href="http://prismwiki.codegear.com/en/Cirrus">the original</a> on 23 January 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-29"><span class="mw-cite-backlink"><b><a href="#cite_ref-29">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.gnu.org/software/emacs/manual/html_node/elisp/Advising-Functions.html">"Emacs Advice Functions"</a>. GNU Project. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20111024211408/http://www.gnu.org/software/emacs/elisp/html_node/Advising-Functions.html">Archived</a> from the original on 24 October 2011<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-30"><span class="mw-cite-backlink"><b><a href="#cite_ref-30">^</a></b></span> <span class="reference-text"><a href="Monad_(functional_programming)" title="Monad (functional programming)">Monads</a> allow program semantics to be altered by changing the type of the program without altering its code: <cite id="CITEREFDe_Meuter1997" class="citation journal cs1">De Meuter, Wolfgang (1997). "Monads As a theoretical basis for AOP". <i>International Workshop on Aspect-Oriented Programming at ECOOP</i>: 25. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a>&nbsp;<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.25.8262">10.1.1.25.8262</a></span>.</cite> <cite id="CITEREFTabareauFigueroaTanter2013" class="citation book cs1">Tabareau, Nicolas; Figueroa, Ismael; Tanter, Éric (March 2013). <a rel="nofollow" class="external text" href="http://dl.acm.org/citation.cfm?id=2451457">"A typed monadic embedding of aspects"</a>. <a rel="nofollow" class="external text" href="https://hal.inria.fr/hal-00763695/file/main.pdf"><i>Proceedings of the 12th annual international conference on Aspect-oriented software development</i></a> <span class="cs1-format">(PDF)</span>. Aosd '13. pp.&nbsp;<span class="nowrap">171–</span>184. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F2451436.2451457">10.1145/2451436.2451457</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>9781450317665</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a>&nbsp;<a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:27256161">27256161</a>.</cite> <a href="Type_class" title="Type class">Type classes</a> allow additional capabilities to be added to a type: <cite id="CITEREFSulzmannWang2007" class="citation book cs1">Sulzmann, Martin; Wang, Meng (March 2007). <a rel="nofollow" class="external text" href="http://portal.acm.org/citation.cfm?id=1233842">"Aspect-oriented programming with type classes"</a>. <a rel="nofollow" class="external text" href="https://kar.kent.ac.uk/47468/1/local_143541.pdf"><i>Proceedings of the 6th workshop on Foundations of aspect-oriented languages</i></a> <span class="cs1-format">(PDF)</span>. pp.&nbsp;<span class="nowrap">65–</span>74. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F1233833.1233842">10.1145/1233833.1233842</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-1595936615</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a>&nbsp;<a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:3253858">3253858</a>.</cite>.</span>
</li>
<li id="cite_note-31"><span class="mw-cite-backlink"><b><a href="#cite_ref-31">^</a></b></span> <span class="reference-text">Numerous others: <a rel="nofollow" class="external text" href="http://www.caesarj.org/">CaesarJ</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081219181529/http://caesarj.org/">Archived</a> 2008-12-19 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://composestar.sourceforge.net/">Compose*</a> <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20050821193804/http://composestar.sourceforge.net/">Archived</a> 2005-08-21 at Wikiwix, <a rel="nofollow" class="external text" href="http://dynaop.dev.java.net/">Dynaop</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070724061030/https://dynaop.dev.java.net/">Archived</a> 2007-07-24 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://jac.objectweb.org/">JAC</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20040619135517/http://jac.objectweb.org/">Archived</a> 2004-06-19 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a href="Google_Guice" title="Google Guice">Google Guice</a> (as part of its functionality), <a rel="nofollow" class="external text" href="http://www.csg.is.titech.ac.jp/~chiba/javassist/">Javassist</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20040901095342/http://www.csg.is.titech.ac.jp/~chiba/javassist/">Archived</a> 2004-09-01 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://ssel.vub.ac.be/jasco/">JAsCo (and AWED)</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050411010213/http://ssel.vub.ac.be/jasco/">Archived</a> 2005-04-11 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.ics.uci.edu/~trungcn/jaml/">JAML</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050415091244/http://www.ics.uci.edu/~trungcn/jaml/">Archived</a> 2005-04-15 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://labs.jboss.com/portal/jbossaop">JBoss AOP</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20061017211354/http://labs.jboss.com/portal/jbossaop/">Archived</a> 2006-10-17 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://roots.iai.uni-bonn.de/research/logicaj">LogicAJ</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060504154852/http://roots.iai.uni-bonn.de/research/logicaj/">Archived</a> 2006-05-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.objectteams.org/">Object Teams</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050831200910/http://objectteams.org/">Archived</a> 2005-08-31 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://prose.ethz.ch/">PROSE</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070124094344/http://prose.ethz.ch/">Archived</a> 2007-01-24 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.aspectbench.org/">The AspectBench Compiler for AspectJ (abc)</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20141216200424/http://aspectbench.org/">Archived</a> 2014-12-16 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a href="Spring_framework" class="mw-redirect" title="Spring framework">Spring framework</a> (as part of its functionality), <a href="Seasar" title="Seasar">Seasar</a>, <a rel="nofollow" class="external text" href="http://roots.iai.uni-bonn.de/research/jmangler/">The JMangler Project</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20051028191025/http://roots.iai.uni-bonn.de/research/jmangler/">Archived</a> 2005-10-28 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://injectj.sourceforge.net/">InjectJ</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050405080539/http://injectj.sourceforge.net/">Archived</a> 2005-04-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.csg.is.titech.ac.jp/projects/gluonj/">GluonJ</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070206010219/http://www.csg.is.titech.ac.jp/projects/gluonj/">Archived</a> 2007-02-06 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.st.informatik.tu-darmstadt.de/static/pages/projects/AORTA/Steamloom.jsp">Steamloom</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070818100432/http://www.st.informatik.tu-darmstadt.de/static/pages/projects/AORTA/Steamloom.jsp">Archived</a> 2007-08-18 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
<li id="cite_note-32"><span class="mw-cite-backlink"><b><a href="#cite_ref-32">^</a></b></span> <span class="reference-text">Many: <a rel="nofollow" class="external text" href="http://i.gotfresh.info/2007/12/7/advised-methods-for-javascript-with-prototype/">Advisable</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20080704052200/http://i.gotfresh.info/2007/12/7/advised-methods-for-javascript-with-prototype">Archived</a> 2008-07-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/ajaxpect/">Ajaxpect</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160709203939/https://code.google.com/p/ajaxpect/">Archived</a> 2016-07-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://plugins.jquery.com/project/AOP">jQuery AOP Plugin</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20080113184156/http://plugins.jquery.com/project/AOP">Archived</a> 2008-01-13 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://aspectes.tigris.org/">Aspectes</a> <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20060508035836/http://aspectes.tigris.org/">Archived</a> 2006-05-08 at Wikiwix, <a rel="nofollow" class="external text" href="http://www.aspectjs.com/">AspectJS</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081216010832/http://www.aspectjs.com/">Archived</a> 2008-12-16 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.cerny-online.com/cerny.js/">Cerny.js</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070627024906/http://www.cerny-online.com/cerny.js/">Archived</a> 2007-06-27 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://dojotoolkit.org/">Dojo Toolkit</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20060221211958/http://www.dojotoolkit.org/">Archived</a> 2006-02-21 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://humax.sourceforge.net/">Humax Web Framework</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081209103012/http://humax.sourceforge.net/">Archived</a> 2008-12-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/joose-js/">Joose</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150318193601/http://code.google.com/p/joose-js/">Archived</a> 2015-03-18 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a href="Prototype.js" class="mw-redirect" title="Prototype.js">Prototype</a> – <a rel="nofollow" class="external text" href="http://www.prototypejs.org/api/function/wrap">Prototype Function#wrap</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090505233620/http://www.prototypejs.org/api/function/wrap">Archived</a> 2009-05-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://developer.yahoo.com/yui/3/api/Do.html">YUI 3 (Y.Do)</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110125115930/https://developer.yahoo.com/yui/3/api/Do.html">Archived</a> 2011-01-25 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
<li id="cite_note-33"><span class="mw-cite-backlink"><b><a href="#cite_ref-33">^</a></b></span> <span class="reference-text">Using built-in support for categories (which allows the encapsulation of aspect code) and event-driven programming (which allows the definition of <i>before</i> and after <i>event</i> handlers).</span>
</li>
<li id="cite_note-34"><span class="mw-cite-backlink"><b><a href="#cite_ref-34">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://luaforge.net/projects/aspectlua/">"AspectLua"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150717094121/http://luaforge.net/projects/aspectlua/">Archived</a> from the original on 17 July 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-35"><span class="mw-cite-backlink"><b><a href="#cite_ref-35">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://archive.today/20120724151524/http://www.bramadams.org/makao/">"MAKAO, re(verse)-engineering build systems"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.bramadams.org/makao/">the original</a> on 24 July 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-36"><span class="mw-cite-backlink"><b><a href="#cite_ref-36">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.sable.mcgill.ca/mclab/aspectmatlab/">"McLab"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150924093214/http://www.sable.mcgill.ca/mclab/aspectmatlab/">Archived</a> from the original on 24 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-37"><span class="mw-cite-backlink"><b><a href="#cite_ref-37">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20101205005108/http://www.cs.princeton.edu/sip/projects/aspectml/">"AspectML – Aspect-oriented Functional Programming Language Research"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.cs.princeton.edu/sip/projects/aspectml/">the original</a> on 5 December 2010<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-38"><span class="mw-cite-backlink"><b><a href="#cite_ref-38">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://github.com/rsdn/nemerle/blob/master/README.md">"nemerle/README.md at master · rsdn/nemerle"</a>. <i><a href="GitHub" title="GitHub">GitHub</a></i><span class="reference-accessdate">. Retrieved <span class="nowrap">22 March</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-39"><span class="mw-cite-backlink"><b><a href="#cite_ref-39">^</a></b></span> <span class="reference-text"><cite id="CITEREFAdam_Kennedy" class="citation web cs1">Adam Kennedy. <a rel="nofollow" class="external text" href="https://metacpan.org/module/Aspect">"Aspect – Aspect-Oriented Programming (AOP) for Perl – metacpan.org"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20130831064935/https://metacpan.org/module/Aspect">Archived</a> from the original on 31 August 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-40"><span class="mw-cite-backlink"><b><a href="#cite_ref-40">^</a></b></span> <span class="reference-text">Several: <a rel="nofollow" class="external text" href="http://aop.io">PHP-AOP (AOP.io)</a> <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20140818050736/http://aop.io/">Archived</a> 2014-08-18 at Wikiwix, <a rel="nofollow" class="external text" href="http://go.aopphp.com">Go! AOP framework</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20130301043014/http://go.aopphp.com/">Archived</a> 2013-03-01 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://code.google.com/p/phpaspect/">PHPaspect</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160822234503/https://code.google.com/p/phpaspect/">Archived</a> 2016-08-22 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.seasar.org/en/php5/">Seasar.PHP</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20051226040309/http://www.seasar.org/en/php5/">Archived</a> 2005-12-26 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://archive.today/20120712081326/http://php-aop.googlecode.com/">PHP-AOP</a>, <a rel="nofollow" class="external text" href="https://flow.neos.io/">Flow</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20180104132543/https://flow.neos.io/">Archived</a> 2018-01-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://github.com/AOP-PHP/AOP">AOP PECL Extension</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20170411031809/https://github.com/AOP-PHP/AOP">Archived</a> 2017-04-11 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
<li id="cite_note-41"><span class="mw-cite-backlink"><b><a href="#cite_ref-41">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20120303120515/https://www.bigzaphod.org/whirl/dma/docs/aspects/aspects-man.html">"Aspect-Oriented Programming in Prolog"</a>. <i>bigzaphod.org</i>. 14 December 2005. Archived from <a rel="nofollow" class="external text" href="http://www.bigzaphod.org/whirl/dma/docs/aspects/aspects-man.html">the original</a> on 3 March 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-42"><span class="mw-cite-backlink"><b><a href="#cite_ref-42">^</a></b></span> <span class="reference-text">Several: <a rel="nofollow" class="external text" href="http://peak.telecommunity.com/">PEAK</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050409082546/http://peak.telecommunity.com/">Archived</a> 2005-04-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110609153559/http://old.aspyct.org/">Aspyct AOP</a>, <a rel="nofollow" class="external text" href="http://www.cs.tut.fi/~ask/aspects/aspects.html">Lightweight Python AOP</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20041009194711/http://www.cs.tut.fi/~ask/aspects/aspects.html">Archived</a> 2004-10-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.logilab.org/projects/aspects">Logilab's aspect module</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050309034259/http://www.logilab.org/projects/aspects">Archived</a> 2005-03-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://pythius.sourceforge.net/">Pythius</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20050408072457/http://pythius.sourceforge.net/">Archived</a> 2005-04-08 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://springpython.webfactional.com/1.1.x/reference/html/aop.html">Spring Python's AOP module</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20160304055741/http://springpython.webfactional.com/1.1.x/reference/html/aop.html">Archived</a> 2016-03-04 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://pytilities.sourceforge.net/doc/1.1.0/guide/aop/">Pytilities' AOP module</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110825101213/http://pytilities.sourceforge.net/doc/1.1.0/guide/aop/">Archived</a> 2011-08-25 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://python-aspectlib.readthedocs.org/en/latest/">aspectlib</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20141105061010/http://python-aspectlib.readthedocs.org/en/latest/">Archived</a> 2014-11-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
<li id="cite_note-43"><span class="mw-cite-backlink"><b><a href="#cite_ref-43">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://planet.racket-lang.org/display.ss?package=aspectscheme.plt&amp;owner=dutchyn">"PLaneT Package Repository&nbsp;: PLaneT &gt; dutchyn &gt; aspectscheme.plt"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150905062740/http://planet.racket-lang.org/display.ss?package=aspectscheme.plt&amp;owner=dutchyn">Archived</a> from the original on 5 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-44"><span class="mw-cite-backlink"><b><a href="#cite_ref-44">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://aspectr-fork.sourceforge.net/">"AspectR – Simple aspect-oriented programming in Ruby"</a>. <a rel="nofollow" class="external text" href="http://archive.wikiwix.com/cache/20150812003432/http://aspectr-fork.sourceforge.net/">Archived</a> from the original on 12 August 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-45"><span class="mw-cite-backlink"><b><a href="#cite_ref-45">^</a></b></span> <span class="reference-text"><cite id="CITEREFDean_Wampler" class="citation web cs1">Dean Wampler. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20071026055811/http://aquarium.rubyforge.org/">"Home"</a>. Archived from <a rel="nofollow" class="external text" href="http://aquarium.rubyforge.org/">the original</a> on 26 October 2007<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-46"><span class="mw-cite-backlink"><b><a href="#cite_ref-46">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://github.com/gcao/aspector">"gcao/aspector"</a>. <i>GitHub</i>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150104180534/https://github.com/gcao/aspector">Archived</a> from the original on 4 January 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-47"><span class="mw-cite-backlink"><b><a href="#cite_ref-47">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20060106112030/http://www.prakinf.tu-ilmenau.de/~hirsch/Projects/Squeak/AspectS/">"AspectS"</a>. <i>tu-ilmenau.de</i>. Archived from <a rel="nofollow" class="external text" href="http://www.prakinf.tu-ilmenau.de/~hirsch/Projects/Squeak/AspectS/">the original</a> on 6 January 2006<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-48"><span class="mw-cite-backlink"><b><a href="#cite_ref-48">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20150729062351/http://csl.ensm-douai.fr/MetaclassTalk">"MetaclassTalk: Reflection and Meta-Programming in Smalltalk"</a>. Archived from <a rel="nofollow" class="external text" href="http://csl.ensm-douai.fr/MetaclassTalk">the original</a> on 29 July 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
<li id="cite_note-49"><span class="mw-cite-backlink"><b><a href="#cite_ref-49">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.iit.edu/~concur/weavr">"WEAVR"</a>. <i>iit.edu</i>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081212200221/http://www.iit.edu/~concur/weavr/">Archived</a> from the original on 12 December 2008<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2018</span>.</cite></span>
</li>
<li id="cite_note-50"><span class="mw-cite-backlink"><b><a href="#cite_ref-50">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://code.google.com/p/aspectxml/">"aspectxml – An Aspect-Oriented XML Weaving Engine (AXLE) – Google Project Hosting"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20150912161613/http://code.google.com/p/aspectxml/">Archived</a> from the original on 12 September 2015<span class="reference-accessdate">. Retrieved <span class="nowrap">11 August</span> 2015</span>.</cite></span>
</li>
</ol></div></div>
<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>
<ul><li><cite id="CITEREFKiczalesLampingMendhekarMaeda1997" class="citation conference cs1"><a href="Gregor_Kiczales" title="Gregor Kiczales">Kiczales, G.</a>; Lamping, J.; Mendhekar, A.; Maeda, C.; Lopes, C.; Loingtier, J. M.; Irwin, J. (1997). <a rel="nofollow" class="external text" href="http://www.cs.ubc.ca/~gregor/papers/kiczales-ECOOP1997-AOP.pdf"><i>Aspect-oriented programming</i></a> <span class="cs1-format">(PDF)</span>. <a href="European_Conference_on_Object-Oriented_Programming" title="European Conference on Object-Oriented Programming">ECOOP</a>'97. <i>Proceedings of the 11th European Conference on Object-Oriented Programming</i>. <a href="Lecture_Notes_in_Computer_Science" title="Lecture Notes in Computer Science">Lecture Notes in Computer Science</a> (LNCS). Vol.&nbsp;1241. pp.&nbsp;<span class="nowrap">220–</span>242. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a>&nbsp;<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.115.8660">10.1.1.115.8660</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2FBFb0053381">10.1007/BFb0053381</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>3-540-63089-9</bdi>.</cite> The paper generally considered to be the authoritative reference for AOP.</li>
<li><cite id="CITEREFRobert_E._FilmanTzilla_ElradSiobhán_ClarkeMehmet_Aksit2004" class="citation book cs1">Robert E. Filman; Tzilla Elrad; <a href="Siobh%C3%A1n_Clarke" title="Siobhán Clarke">Siobhán Clarke</a>; Mehmet Aksit (2004). <i>Aspect-Oriented Software Development</i>. Addison-Wesley. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-0-321-21976-3</bdi>.</cite></li>
<li><cite id="CITEREFRenaud_Pawlak,_Lionel_SeinturierJean-Philippe_Retaillé2005" class="citation book cs1">Renaud Pawlak, Lionel Seinturier &amp; Jean-Philippe Retaillé (2005). <i>Foundations of AOP for J2EE Development</i>. Apress. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-1-59059-507-7</bdi>.</cite></li>
<li><cite id="CITEREFLaddad2003" class="citation book cs1">Laddad, Ramnivas (2003). <span class="id-lock-registration" title="Free registration required"><a rel="nofollow" class="external text" href="https://archive.org/details/aspectjinactionp00ladd"><i>AspectJ in Action: Practical Aspect-Oriented Programming</i></a></span>. Manning. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-1-930110-93-9</bdi>.</cite></li>
<li><cite id="CITEREFJacobsonPan-Wei_Ng2005" class="citation book cs1"><a href="Ivar_Jacobson" title="Ivar Jacobson">Jacobson, Ivar</a>; Pan-Wei Ng (2005). <i>Aspect-Oriented Software Development with Use Cases</i>. Addison-Wesley. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-0-321-26888-4</bdi>.</cite></li>
<li><a rel="nofollow" class="external text" href="http://www.cmsdevelopment.com/en/articles/aosdinphp/">Aspect-oriented Software Development and PHP, Dmitry Sheiko, 2006</a></li>
<li><cite id="CITEREFSiobhán_ClarkeElisa_Baniassad2005" class="citation book cs1"><a href="Siobh%C3%A1n_Clarke" title="Siobhán Clarke">Siobhán Clarke</a> &amp; Elisa Baniassad (2005). <i>Aspect-Oriented Analysis and Design: The Theme Approach</i>. Addison-Wesley. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-0-321-24674-5</bdi>.</cite></li>
<li><cite id="CITEREFRaghu_Yedduladoddi2009" class="citation book cs1">Raghu Yedduladoddi (2009). <i>Aspect Oriented Software Development: An Approach to Composing UML Design Models</i>. VDM. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>978-3-639-12084-4</bdi>.</cite></li>
<li>"Adaptive Object-Oriented Programming Using Graph-Based Customization" – Lieberherr, Silva-Lepe, <i>et al.</i> – 1994</li>
<li><cite id="CITEREFZambrano_Polo_y_La_Borda2013" class="citation journal cs1">Zambrano Polo y La Borda, Arturo Federico (5 June 2013). <a rel="nofollow" class="external text" href="http://sedici.unlp.edu.ar/handle/10915/35861">"Addressing aspect interactions in an industrial setting: experiences, problems and solutions"</a>: 159. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://doi.org/10.35537%2F10915%2F35861">10.35537/10915/35861</a></span><span class="reference-accessdate">. Retrieved <span class="nowrap">30 May</span> 2014</span>.</cite> <span class="cs1-visible-error citation-comment"><code class="cs1-code">{{cite journal}}</code>: </span><span class="cs1-visible-error citation-comment">Cite journal requires <code class="cs1-code">|journal=</code> (help)</span></li>
<li>Wijesuriya, Viraj Brian (2016-08-30) <i><a rel="nofollow" class="external text" href="https://www.slideshare.net/tyrantbrian/aspect-oriented-development">Aspect Oriented Development, Lecture Notes, University of Colombo School of Computing, Sri Lanka</a></i></li>
<li><cite id="CITEREFGroves2013" class="citation book cs1">Groves, Matthew D. (2013). <i>AOP in .NET</i>. Manning. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a>&nbsp;<bdi>9781617291142</bdi>.</cite></li></ul>
<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>
<ul><li><a href="Eric_Bodden" title="Eric Bodden">Eric Bodden</a>'s <a rel="nofollow" class="external text" href="http://www.sable.mcgill.ca/aop.net/">list of AOP tools</a> in .NET framework</li>
<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20030821074213/http://aosd.net/conference/">Aspect-Oriented Software Development</a>, annual conference on AOP</li>
<li><a rel="nofollow" class="external text" href="http://www.eclipse.org/aspectj/doc/released/progguide/">AspectJ Programming Guide</a></li>
<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20141216200424/http://aspectbench.org/">The AspectBench Compiler for AspectJ</a>, another Java implementation</li>
<li><a rel="nofollow" class="external text" href="http://www.ibm.com/developerworks/views/java/libraryview.jsp?search_by=AOP@work:">Series of IBM developerWorks articles on AOP</a></li>
<li><cite id="CITEREFLaddad2002" class="citation web cs1">Laddad, Ramnivas (18 January 2002). <a rel="nofollow" class="external text" href="https://www.infoworld.com/article/2073918/i-want-my-aop---part-1.html">"I want my AOP!, Part 1"</a>. <i><a href="JavaWorld" class="mw-redirect" title="JavaWorld">JavaWorld</a></i><span class="reference-accessdate">. Retrieved <span class="nowrap">20 July</span> 2020</span>.</cite> A detailed series of articles on basics of aspect-oriented programming and AspectJ</li>
<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090821185951/http://codefez.com/what-is-aspect-oriented-programming/">What is Aspect-Oriented Programming?</a>, introduction with RemObjects Taco</li>
<li><a rel="nofollow" class="external text" href="http://www.cis.uab.edu/gray/Research/C-SAW/">Constraint-Specification Aspect Weaver</a></li>
<li><a rel="nofollow" class="external text" href="http://www.devx.com/Java/Article/28422">Aspect- vs. Object-Oriented Programming: Which Technique, When?</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20210415064448/http://www.devx.com/Java/Article/28422">Archived</a> 15 April 2021 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></li>
<li><a rel="nofollow" class="external text" href="http://video.google.com/videoplay?docid=8566923311315412414&amp;q=engEDU">Gregor Kiczales, Professor of Computer Science, explaining AOP</a>, video 57 min.</li>
<li><a rel="nofollow" class="external text" href="http://database.ittoolbox.com/documents/academic-articles/what-does-aspectoriented-programming-mean-to-cobol-4570">Aspect Oriented Programming in COBOL</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081217055353/http://database.ittoolbox.com/documents/academic-articles/what-does-aspectoriented-programming-mean-to-cobol-4570">Archived</a> 2008-12-17 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></li>
<li><a rel="nofollow" class="external text" href="http://static.springframework.org/spring/docs/2.0.x/reference/aop.html">Aspect-Oriented Programming in Java with Spring Framework</a></li>
<li><a rel="nofollow" class="external text" href="http://www.sharpcrafters.com/aop.net">Wiki dedicated to AOP methods on.NET</a></li>
<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090124183215/http://dssg.cs.umb.edu/wiki/index.php/Early_Aspects_for_Business_Process_Modeling">Early Aspects for Business Process Modeling (An Aspect Oriented Language for BPMN)</a></li>
<li><a rel="nofollow" class="external text" href="http://java2novice.com/spring/aop-and-aspectj-introduction/">Spring AOP and AspectJ Introduction</a></li>
<li><a rel="nofollow" class="external text" href="http://www.cs.bilkent.edu.tr/~bedir/CS586-AOSD">AOSD Graduate Course at Bilkent University</a></li>
<li><a rel="nofollow" class="external text" href="http://www.se-radio.net/podcast/2008-08/episode-106-introduction-aop">Introduction to AOP – Software Engineering Radio Podcast Episode 106</a></li>
<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20120801133941/http://innoli.com/en/Innoli-EN/OpenSource.html">An Objective-C implementation of AOP by Szilveszter Molnar</a></li>
<li><a rel="nofollow" class="external text" href="https://github.com/forensix/MGAOP">Aspect-Oriented programming for iOS and OS X by Manuel Gebele</a></li>
<li><a rel="nofollow" class="external text" href="https://community.devexpress.com/blogs/wpf/archive/2013/12/04/devexpress-mvvm-framework-introduction-to-poco-viewmodels.aspx">DevExpress MVVM Framework. Introduction to POCO ViewModels</a></li></ul>
<div class="navbox-styles"><style data-mw-deduplicate="TemplateStyles:r1129693374">
/* start https://en.wikipedia.org/ */


.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}


/* end https://en.wikipedia.org/ */
</style><style data-mw-deduplicate="TemplateStyles:r1236075235">
/* start https://en.wikipedia.org/ */


.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}


/* end https://en.wikipedia.org/ */
</style></div><div role="navigation" class="navbox" aria-labelledby="Aspect-oriented_programming48" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><style data-mw-deduplicate="TemplateStyles:r1239400231">
/* start https://en.wikipedia.org/ */


.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}


/* end https://en.wikipedia.org/ */
</style><div id="Aspect-oriented_programming48" style="font-size:114%;margin:0 4em"></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Concepts</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Advice_(programming)" title="Advice (programming)">Advice</a></li>
<li><a href="Aspect_(computer_programming)" title="Aspect (computer programming)">Aspect</a></li>

<li><a href="Aspect_weaver" title="Aspect weaver">Aspect weaver</a></li>
<li><a href="Cross-cutting_concern" title="Cross-cutting concern">Cross-cutting concerns</a></li>
<li><a href="Join_point" title="Join point">Join point</a></li>
<li><a href="Pointcut" title="Pointcut">Pointcut</a></li>
<li><a href="Composition_filters" title="Composition filters">Composition filters</a></li></ul>
</div></td><td class="noviewer navbox-image" rowspan="2" style="width:1px;padding:0 0 0 2px"><div><span typeof="mw:File"></span></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Languages</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="AspectC%2B%2B" title="AspectC++">AspectC++</a></li>
<li><a href="AspectJ" title="AspectJ">AspectJ</a></li>
<li><a href="AspectJ#AspectWerkz" title="AspectJ">AspectWerkz</a></li></ul>
</div></td></tr></tbody></table></div>
<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>
<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>
<li><a href="Modular_programming" title="Modular programming">Modular</a></li>
<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>
<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>
<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>
<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>
<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>
<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a><br>(<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>
<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>
<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>
<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>
<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Declarative_programming" title="Declarative programming">Declarative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a><br>(<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>
<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>
<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>
<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>
<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>
<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>
<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>
<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>
<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>
<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>
<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>
<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>
<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>
<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>
<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>
<li><a href="Stream_processing" title="Stream processing">Streams</a></li>
<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Logic_programming" title="Logic programming">Logic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>
<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>
<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>
<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>
<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>
<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>
<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>
<li><a href="Query_language" title="Query language">Query</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>
<li><a href="Array_programming" title="Array programming">Array</a></li>
<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>
<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>
<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>
<li><a href="End-user_development" title="End-user development">End-user</a></li>
<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>
<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>
<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>
<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>
<li><a href="Low-code_development_platform" title="Low-code development platform">Low-code</a></li>
<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>
<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>
<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>
<li><a href="Page_description_language" title="Page description language">Page description</a></li>
<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>
<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>
<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>
<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>
<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>
<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>
<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>
<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>
<li><a href="System_programming_language" title="System programming language">System</a></li>
<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>
<li><a href="Template_processor" title="Template processor">Templating</a></li>
<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>
<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>
</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Concurrent_computing" title="Concurrent computing">Concurrent</a>,<br><a href="Distributed_computing" title="Distributed computing">distributed</a>,<br><a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>
<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>
<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>
<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>
<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>
<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>
<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>
<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>
<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>
<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>
<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>
<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>
<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>
<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>
<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>
<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>
<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>
<li><a href="Generic_programming" title="Generic programming">Generic</a></li>
<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>
<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>
<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>
<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>
<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>
<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>
<li><a href="Reflective_programming" title="Reflective programming">Reflective</a></li>
<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>
<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>
<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation<br>of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">
<ul>
<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>
<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>
<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>
<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>
<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>
<li><a href="Literate_programming" title="Literate programming">Literate</a></li>
<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>
<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>
</div></td></tr></tbody></table></div>
<div class="navbox-styles"></div><div role="navigation" class="navbox authority-control" aria-labelledby="Authority_control_databases_frameless&amp;#124;text-top&amp;#124;10px&amp;#124;alt=Edit_this_at_Wikidata&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q30267#identifiers&amp;#124;class=noprint&amp;#124;Edit_this_at_Wikidata897" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Authority_control_databases_frameless&amp;#124;text-top&amp;#124;10px&amp;#124;alt=Edit_this_at_Wikidata&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q30267#identifiers&amp;#124;class=noprint&amp;#124;Edit_this_at_Wikidata897" style="font-size:114%;margin:0 4em">Authority control databases </div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">National</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><span class="uid"><a rel="nofollow" class="external text" href="https://d-nb.info/gnd/4724728-9">Germany</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://id.loc.gov/authorities/sh2005004988">United States</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb14544142k">France</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://data.bnf.fr/ark:/12148/cb14544142k">BnF data</a></span></li><li><span class="uid"><a rel="nofollow" class="external text" href="https://www.nli.org.il/en/authorities/987007561682705171">Israel</a></span></li></ul></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em"><ul><li><span class="uid"><a rel="nofollow" class="external text" href="https://lux.collections.yale.edu/view/concept/9686f81d-8aa7-4425-9e32-427ed7300abd">Yale LUX</a></span></li></ul></div></td></tr></tbody></table></div></div><!--htdig_noindex--><div><div class="zim-footer">
This article is issued from <a class="external text" title="Last edited on 2025-04-18" href="https://en.wikipedia.org/wiki/?title=Aspect-oriented_programming&amp;oldid=1286161536">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>

</body></html>